MAYBE 5.9030000000000005 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could not be shown:



HASKELL
  ↳ IFR

mainModule Main
  (((^^) :: Float  ->  Int  ->  Float) :: Float  ->  Int  ->  Float)

module Main where
  import qualified Prelude



If Reductions:
The following If expression
if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero

is transformed to
primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y))
primDivNatS0 x y False = Zero

The following If expression
if n >= 0 then x ^ n else recip (x ^ (`negate` n))

is transformed to
prPr0 x n True = x ^ n
prPr0 x n False = recip (x ^ (`negate` n))



↳ HASKELL
  ↳ IFR
HASKELL
      ↳ BR

mainModule Main
  (((^^) :: Float  ->  Int  ->  Float) :: Float  ->  Int  ->  Float)

module Main where
  import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule Main
  (((^^) :: Float  ->  Int  ->  Float) :: Float  ->  Int  ->  Float)

module Main where
  import qualified Prelude



Cond Reductions:
The following Function with conditions
g x n
 | even n
 = g (x * x) (n `quot` 2)
 | otherwise
 = f x (n - 1) (x * y)

is transformed to
g x n = g2 x n

g1 x n True = g (x * x) (n `quot` 2)
g1 x n False = g0 x n otherwise

g0 x n True = f x (n - 1) (x * y)

g2 x n = g1 x n (even n)

The following Function with conditions
f vv 0 y = y
f x n y = 
g x n
where 
g x n
 | even n
 = g (x * x) (n `quot` 2)
 | otherwise
 = f x (n - 1) (x * y)

is transformed to
f vv yu y = f4 vv yu y
f x n y = f0 x n y

f0 x n y = 
g x n
where 
g x n = g2 x n
g0 x n True = f x (n - 1) (x * y)
g1 x n True = g (x * x) (n `quot` 2)
g1 x n False = g0 x n otherwise
g2 x n = g1 x n (even n)

f3 True vv yu y = y
f3 yv yw yx yy = f0 yw yx yy

f4 vv yu y = f3 (yu == 0) vv yu y
f4 yz zu zv = f0 yz zu zv

The following Function with conditions
^ x 0 = 1
^ x n
 | n > 0
 = f x (n - 1) x
where 
f vv 0 y = y
f x n y = 
g x n
where 
g x n
 | even n
 = g (x * x) (n `quot` 2)
 | otherwise
 = f x (n - 1) (x * y)
^ vw vx = error []

is transformed to
^ x zy = pr4 x zy
^ x n = pr2 x n
^ vw vx = pr0 vw vx

pr0 vw vx = error []

pr2 x n = 
pr1 x n (n > 0)
where 
f vv yu y = f4 vv yu y
f x n y = f0 x n y
f0 x n y = 
g x n
where 
g x n = g2 x n
g0 x n True = f x (n - 1) (x * y)
g1 x n True = g (x * x) (n `quot` 2)
g1 x n False = g0 x n otherwise
g2 x n = g1 x n (even n)
f3 True vv yu y = y
f3 yv yw yx yy = f0 yw yx yy
f4 vv yu y = f3 (yu == 0) vv yu y
f4 yz zu zv = f0 yz zu zv
pr1 x n True = f x (n - 1) x
pr1 x n False = pr0 x n
pr2 zw zx = pr0 zw zx

pr3 True x zy = 1
pr3 zz vuu vuv = pr2 vuu vuv

pr4 x zy = pr3 (zy == 0) x zy
pr4 vuw vux = pr2 vuw vux

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule Main
  (((^^) :: Float  ->  Int  ->  Float) :: Float  ->  Int  ->  Float)

module Main where
  import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
pr1 x n (n > 0)
where 
f vv yu y = f4 vv yu y
f x n y = f0 x n y
f0 x n y = 
g x n
where 
g x n = g2 x n
g0 x n True = f x (n - 1) (x * y)
g1 x n True = g (x * x) (n `quot` 2)
g1 x n False = g0 x n otherwise
g2 x n = g1 x n (even n)
f3 True vv yu y = y
f3 yv yw yx yy = f0 yw yx yy
f4 vv yu y = f3 (yu == 0) vv yu y
f4 yz zu zv = f0 yz zu zv
pr1 x n True = f x (n - 1) x
pr1 x n False = pr0 x n

are unpacked to the following functions on top level
pr2F0 x n y = pr2F0G y x n

pr2F3 True vv yu y = y
pr2F3 yv yw yx yy = pr2F0 yw yx yy

pr2F vv yu y = pr2F4 vv yu y
pr2F x n y = pr2F0 x n y

pr2Pr1 x n True = pr2F x (n - 1) x
pr2Pr1 x n False = pr0 x n

pr2F4 vv yu y = pr2F3 (yu == 0) vv yu y
pr2F4 yz zu zv = pr2F0 yz zu zv

The bindings of the following Let/Where expression
g x n
where 
g x n = g2 x n
g0 x n True = f x (n - 1) (x * y)
g1 x n True = g (x * x) (n `quot` 2)
g1 x n False = g0 x n otherwise
g2 x n = g1 x n (even n)

are unpacked to the following functions on top level
pr2F0G1 vuy x n True = pr2F0G vuy (x * x) (n `quot` 2)
pr2F0G1 vuy x n False = pr2F0G0 vuy x n otherwise

pr2F0G2 vuy x n = pr2F0G1 vuy x n (even n)

pr2F0G vuy x n = pr2F0G2 vuy x n

pr2F0G0 vuy x n True = pr2F x (n - 1) (x * vuy)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ NumRed

mainModule Main
  (((^^) :: Float  ->  Int  ->  Float) :: Float  ->  Int  ->  Float)

module Main where
  import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
HASKELL
                      ↳ Narrow
                      ↳ Narrow

mainModule Main
  ((^^) :: Float  ->  Int  ->  Float)

module Main where
  import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(vuz5700000))) → new_primDivNatS(vuz5700000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(vuz5800), Succ(vuz49000)) → new_primPlusNat(vuz5800, vuz49000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(vuz1500), Succ(vuz4900)) → new_primMulNat(vuz1500, Succ(vuz4900))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ DependencyGraphProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G12(vuz55, vuz56, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS1, Succ(new_primDivNatS1), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G10(vuz55, vuz56, Zero, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
new_pr2F0G10(vuz55, vuz56, Succ(Zero), bc) → new_pr2F0G12(vuz55, vuz56, bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)

The TRS R consists of the following rules:

new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr8(vuz15, vuz53) → error([])
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr6(vuz15, vuz51) → error([])
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_primPlusNat1(Zero, Zero) → Zero
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_primDivNatS1Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primMulNat0(Zero, Zero) → Zero
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_primDivNatS0(Zero) → Zero
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr1(x0, app(ty_Ratio, x1))
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_sr1(x0, ty_Int)
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_sr1(x0, ty_Integer)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr1(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr1(x0, ty_Float)
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 2 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G10(vuz55, vuz56, Zero, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)

The TRS R consists of the following rules:

new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr8(vuz15, vuz53) → error([])
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr6(vuz15, vuz51) → error([])
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_primPlusNat1(Zero, Zero) → Zero
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_primDivNatS1Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primMulNat0(Zero, Zero) → Zero
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_primDivNatS0(Zero) → Zero
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr1(x0, app(ty_Ratio, x1))
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_sr1(x0, ty_Int)
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_sr1(x0, ty_Integer)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr1(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr1(x0, ty_Float)
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G10(vuz55, vuz56, Zero, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)

The TRS R consists of the following rules:

new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr6(vuz15, vuz51) → error([])
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr8(vuz15, vuz53) → error([])
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr1(x0, app(ty_Ratio, x1))
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_sr1(x0, ty_Int)
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_sr1(x0, ty_Integer)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr1(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr1(x0, ty_Float)
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr2(x0, ty_Integer)
new_sr2(x0, ty_Float)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_sr2(x0, ty_Double)
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_sr3(x0, ty_Integer)
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr(x0, x1, ty_Float)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ MNOCProof
                                ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G10(vuz55, vuz56, Zero, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)

The TRS R consists of the following rules:

new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr6(vuz15, vuz51) → error([])
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr8(vuz15, vuz53) → error([])
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)

The set Q consists of the following terms:

new_sr8(x0, x1)
new_primMulNat0(Zero, Zero)
new_sr1(x0, app(ty_Ratio, x1))
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_primMulNat0(Succ(x0), Zero)
new_sr1(x0, ty_Int)
new_sr1(x0, ty_Integer)
new_primPlusNat1(Zero, Succ(x0))
new_sr1(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr1(x0, ty_Float)
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr9(x0)

We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [17] to decrease Q to the empty set.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ MNOCProof
QDP
                                              ↳ NonTerminationProof
                                ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G10(vuz55, vuz56, Zero, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)

The TRS R consists of the following rules:

new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr6(vuz15, vuz51) → error([])
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr8(vuz15, vuz53) → error([])
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)

Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

new_pr2F0G10(vuz55, vuz56, Zero, bc) → new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)

The TRS R consists of the following rules:

new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr6(vuz15, vuz51) → error([])
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr8(vuz15, vuz53) → error([])
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)


s = new_pr2F0G10(vuz55, vuz56, Zero, bc) evaluates to t =new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc)

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:




Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from new_pr2F0G10(vuz55, vuz56, Zero, bc) to new_pr2F0G10(vuz55, new_sr1(vuz56, bc), Zero, bc).





↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS1, Succ(new_primDivNatS1), bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)

The TRS R consists of the following rules:

new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr8(vuz15, vuz53) → error([])
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_sr1(vuz56, ty_Int) → new_sr10(vuz56)
new_sr6(vuz15, vuz51) → error([])
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_primPlusNat1(Zero, Zero) → Zero
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_primDivNatS1Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_sr1(vuz56, ty_Float) → new_sr13(vuz56)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr1(vuz56, ty_Integer) → new_sr11(vuz56)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primMulNat0(Zero, Zero) → Zero
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_sr1(vuz56, app(ty_Ratio, bg)) → new_sr12(vuz56, bg)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr1(vuz56, ty_Double) → new_sr9(vuz56)
new_primDivNatS0(Zero) → Zero
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr1(x0, app(ty_Ratio, x1))
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_sr1(x0, ty_Int)
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_sr1(x0, ty_Integer)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr1(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr1(x0, ty_Float)
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS1, Succ(new_primDivNatS1), bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr1(x0, app(ty_Ratio, x1))
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_sr1(x0, ty_Int)
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_sr1(x0, ty_Integer)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr1(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr1(x0, ty_Float)
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sr1(x0, app(ty_Ratio, x1))
new_sr1(x0, ty_Int)
new_sr1(x0, ty_Integer)
new_sr1(x0, ty_Double)
new_sr1(x0, ty_Float)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS1, Succ(new_primDivNatS1), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS1, Succ(new_primDivNatS1), bc) at position [2] we obtained the following new rules:

new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, Zero, Succ(new_primDivNatS1), bc)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, Zero, Succ(new_primDivNatS1), bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, Zero, Succ(new_primDivNatS1), bc) at position [3,0] we obtained the following new rules:

new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, Zero, Succ(Zero), bc)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ QDPOrderProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, Zero, Succ(Zero), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_pr2F0G10(vuz55, vuz56, Succ(Succ(Zero)), bc) → new_pr2F0G11(vuz55, vuz56, Zero, Succ(Zero), bc)
new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Zero), ba) → new_pr2F3(vuz94, vuz92, new_sr(vuz92, vuz93, ba), ba)
new_pr2F0G10(vuz55, vuz56, Succ(Succ(Succ(vuz57000))), bc) → new_pr2F0G11(vuz55, vuz56, new_primDivNatS0(vuz57000), Succ(new_primDivNatS0(vuz57000)), bc)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Zero), bd) → new_pr2F3(vuz70, new_sr2(vuz69, bd), vuz68, bd)
The remaining pairs can at least be oriented weakly.

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)
Used ordering: Polynomial interpretation [25]:

POL(Float(x1, x2)) = 0   
POL(Neg(x1)) = 1 + x1   
POL(Pos(x1)) = 1 + x1   
POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL([]) = 0   
POL(app(x1, x2)) = 1 + x1 + x2   
POL(error(x1)) = 0   
POL(new_pr2F0G1(x1, x2, x3, x4, x5)) = 1 + x3   
POL(new_pr2F0G10(x1, x2, x3, x4)) = x3   
POL(new_pr2F0G11(x1, x2, x3, x4, x5)) = 1 + x3   
POL(new_pr2F3(x1, x2, x3, x4)) = x1   
POL(new_primDivNatS0(x1)) = x1   
POL(new_primDivNatS1) = 0   
POL(new_primMulNat0(x1, x2)) = 0   
POL(new_primPlusNat0(x1, x2)) = 0   
POL(new_primPlusNat1(x1, x2)) = 1 + x1 + x2   
POL(new_sr(x1, x2, x3)) = 0   
POL(new_sr0(x1, x2, x3)) = 0   
POL(new_sr10(x1)) = 1 + x1   
POL(new_sr11(x1)) = 1 + x1   
POL(new_sr12(x1, x2)) = 1   
POL(new_sr13(x1)) = 0   
POL(new_sr2(x1, x2)) = x1 + x2   
POL(new_sr3(x1, x2)) = 0   
POL(new_sr4(x1, x2)) = 1 + x2   
POL(new_sr5(x1, x2)) = 0   
POL(new_sr6(x1, x2)) = x1   
POL(new_sr7(x1, x2, x3)) = 0   
POL(new_sr8(x1, x2)) = 0   
POL(new_sr9(x1)) = x1   
POL(ty_Double) = 0   
POL(ty_Float) = 0   
POL(ty_Int) = 1   
POL(ty_Integer) = 1   
POL(ty_Ratio) = 1   

The following usable rules [17] were oriented:

new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Zero) → Zero
new_primDivNatS1Zero



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
QDP
                                                      ↳ DependencyGraphProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)
new_pr2F3(Succ(vuz880), vuz89, vuz90, bb) → new_pr2F0G1(vuz89, vuz90, vuz880, Succ(vuz880), bb)
new_pr2F0G11(vuz68, vuz69, vuz70, Zero, bd) → new_pr2F0G10(vuz68, new_sr3(vuz69, bd), Succ(vuz70), bd)
new_pr2F0G1(vuz92, vuz93, vuz94, Zero, ba) → new_pr2F0G10(new_sr0(vuz92, vuz93, ba), vuz92, Succ(vuz94), ba)
new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ AND
QDP
                                                            ↳ UsableRulesProof
                                                          ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ AND
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
QDP
                                                                ↳ QReductionProof
                                                          ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)

R is empty.
The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ AND
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
QDP
                                                                    ↳ QDPSizeChangeProof
                                                          ↳ QDP
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G11(vuz68, vuz69, vuz70, Succ(Succ(vuz7100)), bd) → new_pr2F0G11(vuz68, vuz69, vuz70, vuz7100, bd)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ AND
                                                          ↳ QDP
QDP
                                                            ↳ UsableRulesProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)

The TRS R consists of the following rules:

new_primDivNatS1Zero
new_sr0(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr0(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr0(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr0(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr6(vuz15, vuz51) → error([])
new_sr4(Pos(vuz150), Neg(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Pos(vuz490)) → Neg(new_primMulNat0(vuz150, vuz490))
new_sr4(Neg(vuz150), Neg(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_sr4(Pos(vuz150), Pos(vuz490)) → Pos(new_primMulNat0(vuz150, vuz490))
new_primMulNat0(Zero, Succ(vuz4900)) → Zero
new_primMulNat0(Succ(vuz1500), Zero) → Zero
new_primMulNat0(Succ(vuz1500), Succ(vuz4900)) → new_primPlusNat0(new_primMulNat0(vuz1500, Succ(vuz4900)), vuz4900)
new_primMulNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(vuz580), vuz4900) → Succ(Succ(new_primPlusNat1(vuz580, vuz4900)))
new_primPlusNat0(Zero, vuz4900) → Succ(vuz4900)
new_primPlusNat1(Succ(vuz5800), Succ(vuz49000)) → Succ(Succ(new_primPlusNat1(vuz5800, vuz49000)))
new_primPlusNat1(Zero, Zero) → Zero
new_primPlusNat1(Zero, Succ(vuz49000)) → Succ(vuz49000)
new_primPlusNat1(Succ(vuz5800), Zero) → Succ(vuz5800)
new_sr7(vuz15, vuz52, ca) → error([])
new_sr8(vuz15, vuz53) → error([])
new_sr5(Float(vuz150, vuz151), Float(vuz500, vuz501)) → Float(new_sr4(vuz150, vuz500), new_sr4(vuz151, vuz501))
new_sr(vuz92, vuz93, app(ty_Ratio, be)) → new_sr7(vuz92, vuz93, be)
new_sr(vuz92, vuz93, ty_Integer) → new_sr8(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Double) → new_sr6(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Int) → new_sr4(vuz92, vuz93)
new_sr(vuz92, vuz93, ty_Float) → new_sr5(vuz92, vuz93)
new_sr2(vuz69, ty_Int) → new_sr10(vuz69)
new_sr2(vuz69, ty_Double) → new_sr9(vuz69)
new_sr2(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr2(vuz69, ty_Float) → new_sr13(vuz69)
new_sr2(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr12(vuz7, bf) → new_sr7(vuz7, vuz7, bf)
new_sr13(vuz7) → new_sr5(vuz7, vuz7)
new_sr11(vuz7) → new_sr8(vuz7, vuz7)
new_sr9(vuz7) → new_sr6(vuz7, vuz7)
new_sr10(vuz7) → new_sr4(vuz7, vuz7)
new_sr3(vuz69, ty_Integer) → new_sr11(vuz69)
new_sr3(vuz69, ty_Int) → new_sr10(vuz69)
new_sr3(vuz69, app(ty_Ratio, bh)) → new_sr12(vuz69, bh)
new_sr3(vuz69, ty_Float) → new_sr13(vuz69)
new_sr3(vuz69, ty_Double) → new_sr9(vuz69)
new_primDivNatS0(Succ(Succ(vuz5700000))) → Succ(new_primDivNatS0(vuz5700000))
new_primDivNatS0(Succ(Zero)) → Succ(new_primDivNatS1)
new_primDivNatS0(Zero) → Zero

The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ AND
                                                          ↳ QDP
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
QDP
                                                                ↳ QReductionProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)

R is empty.
The set Q consists of the following terms:

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_sr8(x0, x1)
new_sr(x0, x1, ty_Integer)
new_sr0(x0, x1, ty_Double)
new_primMulNat0(Zero, Zero)
new_sr2(x0, ty_Int)
new_sr2(x0, app(ty_Ratio, x1))
new_sr(x0, x1, ty_Double)
new_sr6(x0, x1)
new_sr11(x0)
new_sr13(x0)
new_sr3(x0, ty_Float)
new_sr0(x0, x1, ty_Int)
new_primDivNatS1
new_sr4(Neg(x0), Neg(x1))
new_sr12(x0, x1)
new_primPlusNat0(Succ(x0), x1)
new_sr3(x0, ty_Double)
new_sr0(x0, x1, ty_Integer)
new_sr10(x0)
new_primPlusNat1(Zero, Zero)
new_primPlusNat1(Succ(x0), Zero)
new_primMulNat0(Zero, Succ(x0))
new_sr2(x0, ty_Integer)
new_sr7(x0, x1, x2)
new_sr4(Neg(x0), Pos(x1))
new_sr4(Pos(x0), Neg(x1))
new_primPlusNat0(Zero, x0)
new_sr2(x0, ty_Float)
new_primMulNat0(Succ(x0), Zero)
new_sr0(x0, x1, app(ty_Ratio, x2))
new_primDivNatS0(Zero)
new_primDivNatS0(Succ(Zero))
new_sr3(x0, app(ty_Ratio, x1))
new_sr0(x0, x1, ty_Float)
new_primPlusNat1(Zero, Succ(x0))
new_sr2(x0, ty_Double)
new_sr4(Pos(x0), Pos(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_sr3(x0, ty_Int)
new_primDivNatS0(Succ(Succ(x0)))
new_primPlusNat1(Succ(x0), Succ(x1))
new_sr3(x0, ty_Integer)
new_sr5(Float(x0, x1), Float(x2, x3))
new_sr(x0, x1, ty_Int)
new_sr(x0, x1, app(ty_Ratio, x2))
new_sr9(x0)
new_sr(x0, x1, ty_Float)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ AND
                                                          ↳ QDP
                                                          ↳ QDP
                                                            ↳ UsableRulesProof
                                                              ↳ QDP
                                                                ↳ QReductionProof
QDP
                                                                    ↳ QDPSizeChangeProof
                          ↳ QDP
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G1(vuz92, vuz93, vuz94, Succ(Succ(vuz9500)), ba) → new_pr2F0G1(vuz92, vuz93, vuz94, vuz9500, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ NumRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof
                      ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_pr2F0G13(vuz7, vuz8, Succ(Succ(vuz900)), ba) → new_pr2F0G13(vuz7, vuz8, vuz900, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:


Haskell To QDPs